Micron Document
<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 skin-theme-clientpref-day vector-sticky-header-enabled" lang="de" dir="ltr"><head>
<meta charset="UTF-8">
<title>Boyer-Moore-Algorithmus</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://de.wikipedia.org/wiki/Boyer-Moore-Algorithmus"> <link href="./_mw_/ext.math.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link href="./_mw_/ext.gadget.citeRef.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.defaultPlainlinks.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonHide.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonLayout.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonStyle.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiDarkmode.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiResponsive.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.specialSearch.css" rel="stylesheet" type="text/css">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Boyer-Moore-Algorithmus rootpage-Boyer-Moore-Algorithmus skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">Boyer-Moore-Algorithmus</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr"><p>Der <b>Boyer-Moore-Algorithmus</b> ist ein <a href="String-Matching-Algorithmus" title="String-Matching-Algorithmus">String-Matching-Algorithmus</a>. Der Algorithmus wird dazu genutzt, um in einem Text <i>T</i> einen bestimmten Teiltext (Muster <i>M</i>) zu finden und wurde <a href="1977" title="1977">1977</a> von <a href="Robert_S._Boyer" title="Robert S. Boyer">Robert S. Boyer</a> und <a href="J_Strother_Moore" title="J Strother Moore">J Strother Moore</a> entwickelt.
</p>

<div class="mw-heading mw-heading2"><h2 id="Algorithmus">Algorithmus</h2></div>
<p>Das Muster wird am Anfang linksbündig unter den Text geschrieben und dann von rechts nach links Zeichen für Zeichen mit dem Text verglichen. Sobald ein Mismatch auftritt, berechnen zwei <a href="Heuristik#Informatik" title="Heuristik">Heuristiken</a>, wie weit das Suchmuster nach rechts verschoben werden kann.
</p>
<dl><dt>Bad-Character-Heuristik</dt>
<dd>Stimmt beim Vergleich des Musters mit dem Text von rechts nach links ein Zeichen des Musters nicht mit dem Zeichen des Textes überein (<i>Bad-Character</i>), wird im Muster nach dem letzten Vorkommen dieses <i>Bad-Characters</i> gesucht und das Muster so weit verschoben, bis beide Buchstaben übereinander liegen. Existiert dieser <i>Bad-Character</i> nicht im Muster, wird das Muster soweit verschoben, dass sein erstes Zeichen unter dem Nachfolger des <i>Bad-Character</i> liegt. Es kann vorkommen, dass die Bad-Character-Heuristik eine Verschiebung des Musters nach links vorschlägt. In diesem Fall wird um eine Position nach rechts geschoben.</dd>
<dt>Good-Suffix-Heuristik</dt>
<dd>Stimmt beim Vergleich des Musters mit dem Text von rechts nach links ein <a href="Suffix" title="Suffix">Suffix</a> des Musters mit dem Text überein und tritt danach aber ein Mismatch auf, wird das Muster so weit nach rechts geschoben, bis ein Teilwort des Musters wieder auf das Suffix passt. Existiert das Suffix kein zweites Mal im Muster, wird das Muster um seine volle Länge nach rechts verschoben.</dd></dl>
<p>Es kommt vor, dass die beiden Heuristiken unterschiedliche Verschiebungen berechnen. Der Algorithmus wählt immer das <a href="Gr%C3%B6%C3%9Ftes_und_kleinstes_Element" title="Größtes und kleinstes Element">Maximum</a> der beiden Vorschläge, um das Muster nach rechts zu verschieben.
</p><p>Um das Vorgehen effizient zu gestalten, wird für beide Heuristiken in einem Vorverarbeitungsschritt jeweils eine Sprungtabelle errechnet. Die Sprungtabelle für die Bad-Character-Heuristik enthält für jedes im Suchmuster vorkommende Zeichen den Abstand von der Position des letzten Vorkommens im Suchmuster bis zum Ende des Suchmusters. Die Tabelle für die Good-Suffix-Heuristik enthält für jedes Teilmuster (von hinten aus gesehen) den Abstand vom Ende des Musters, ab dem es wieder im Muster vorkommt.
</p>
<div class="mw-heading mw-heading2"><h2 id="Beispiele">Beispiele</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Bad-Character-Heuristik">Bad-Character-Heuristik</h3></div>
<p><b>String:</b> Hoola-Hoola girls like Hooligans
</p><p><b>Suchmuster:</b> Hooligan
</p>
<pre>Hoola-H<span style="color:#00ff00">o</span>ola girls like Hooligans
Hooliga<u><span style="color:#ff0000">n</span></u>
</pre>
<p>Das letzte Zeichen stimmt nicht mit dem letzten des Suchmusters überein, also kann man das Suchmuster bis zum ersten „o“ (des Suchmusters, von hinten gelesen) verschieben:
</p>
<pre>Hoola-H<span style="color:#00ff00">o</span>ola <span style="color:#0000ff">g</span>irls like Hooligans
Hooliga<u><span style="color:#ff0000">n</span></u>
Ho<span style="color:#00ff00">o</span>liga<u><span style="color:#ff0000">n</span></u>
</pre>
<p>Das letzte Zeichen des Suchmusters stimmt nicht mit dem Text überein. An der betreffenden Stelle steht ein „g“, das sich wiederum im Muster an der dritten Position von rechts findet. Wird das Muster um zwei Zeichen nach rechts verschoben, dann „matchen“ die blauen „g“:
</p>
<pre>Hoola-H<span style="color:#00ff00">o</span>ola <span style="color:#0000ff">g</span>irls like Hooligans
Ho<span style="color:#00ff00">o</span>liga<u><span style="color:#ff0000">n</span></u>
Hooli<span style="color:#0000ff">g</span>a<u><span style="color:#ff0000">n</span></u>
</pre>
<p>Das „r“ im String kommt im Muster überhaupt nicht vor. Das ermöglicht – weil bereits der erste verglichene Buchstabe (von hinten) nicht passt – das Verschieben um die komplette Länge des Suchstrings, da hier ausgeschlossen ist, dass das Muster an einer Stelle matcht. Das Gleiche passiert gleich im nächsten Schritt erneut, nur ist es jetzt das Leerzeichen (statt dem „r“), das nicht im Muster vorkommt.
</p>
<pre>Hoola-Hoola <span style="color:#0000ff">g</span>irls like Hooligans
Hooli<span style="color:#0000ff">g</span>a<u><span style="color:#ff0000">n</span></u>
Hooliga<u><span style="color:#ff0000">n</span></u>
<u>Hooligan</u>
</pre>
<p>Danach wurde das Muster gefunden.
</p><p>Ein weiteres Beispiel, bei dem es nicht das letzte Zeichen des Suchstrings betrifft. Deshalb kann der gesamte Suchstring nur bis eine Stelle nach dem gefundenen Mismatch verschoben werden.
</p>
<table class="wikitable">
<tbody><tr>
<td>A
</td>
<td>B
</td>
<td>R
</td>
<td>A
</td>
<td><b>G</b>
</td>
<td>A
</td>
<td>D
</td>
<td>A
</td>
<td>B
</td>
<td>R
</td>
<td>A
</td>
<td>K
</td>
<td>A
</td>
<td>D
</td>
<td>A
</td>
<td><b>B</b>
</td>
<td>R
</td>
<td>A
</td></tr>
<tr>
<td>A
</td>
<td>B
</td>
<td>R
</td>
<td>A
</td>
<td><b>K</b>
</td>
<td>A
</td>
<td>D
</td>
<td>A
</td>
<td>B
</td>
<td>R
</td>
<td>A
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td></tr>
<tr>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>A
</td>
<td>B
</td>
<td>R
</td>
<td>A
</td>
<td>K
</td>
<td>A
</td>
<td>D
</td>
<td>A
</td>
<td>B
</td>
<td>R
</td>
<td><b>A</b>
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td></tr>
<tr>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>&nbsp;
</td>
<td>A
</td>
<td>B
</td>
<td>R
</td>
<td>A
</td>
<td>K
</td>
<td>A
</td>
<td>D
</td>
<td>A
</td>
<td>B
</td>
<td>R
</td>
<td>A
</td></tr></tbody></table>
<p>Skip-Tabelle für das oben aufgeführte Beispiel:
</p>
<table class="wikitable">
<tbody><tr>
<td>A
</td>
<td>B
</td>
<td>R
</td>
<td>K
</td>
<td>D
</td></tr>
<tr>
<td>0
</td>
<td>2
</td>
<td>1
</td>
<td>6
</td>
<td>4
</td></tr></tbody></table>
<p>Der Boyer-Moore-Algorithmus arbeitet am effizientesten, wenn er ein Zeichen vorfindet, das im Suchmuster nicht vorkommt. Die Bad-Character-Regel kommt dann zum Tragen. Dies ist sehr wahrscheinlich bei einem relativ kleinen Muster und einem großen Alphabet, was ihn für einen solchen Fall besonders geeignet macht. In diesem Fall arbeitet der Algorithmus mit einer Effizienz von <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle O\left({\frac {n}{m}}\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>O</mi>
<mrow>
<mo>(</mo>
<mrow class="MJX-TeXAtom-ORD">
<mfrac>
<mi>n</mi>
<mi>m</mi>
</mfrac>
</mrow>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle O\left({\frac {n}{m}}\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/129320d644799f7990a00719066b69231521761e.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.838ex; width:7.812ex; height:4.843ex;" alt="{\displaystyle O\left({\frac {n}{m}}\right)}" loading="lazy"></span> Vergleichen.
</p>
<div class="mw-heading mw-heading3"><h3 id="Good-Suffix-Heuristik">Good-Suffix-Heuristik</h3></div>
<p><b>String:</b> reinesupersauersupesupersupe
</p><p><b>Suchmuster:</b> supersupe
</p>
<pre>reine<u>supe</u>rsauersupesupersupe
super<u>supe</u>
</pre>
<p>Nur die letzten 4 Buchstaben stimmen überein („supe“). Dieses Suffix kommt im Muster ganz am Anfang vor, also kann man das Muster bis dorthin verschieben:
</p>
<pre>reinesupersau<u>e</u>rsupesupersupe
supersup<u>e</u>
</pre>
<p>Nur der letzte Buchstabe „e“ stimmt überein. Wir können das Muster bis zum nächsten Auftreten von „e“ in supersupe verschieben:
</p>
<pre>reinesupersau<u>ersupe</u>supersupe
sup<u>ersupe</u>
</pre>
<p>Nur die letzten Buchstaben „ersupe“ stimmen überein, welche an keiner anderen Stelle im Muster mehr auftreten. Allerdings tritt das Suffix „supe“ sowohl am Ende von „ersupe“ als auch am Anfang des Musters auf.
</p>
<pre>reinesupersauersupesupersupe
supersupe
</pre>
<p>„e“ und „r“ stimmen nicht überein, wir verschieben um eine Position. Dieser Fall tritt mehrmals hintereinander auf:
</p>
<pre>reinesupersauersupesupersupe
supersupe
</pre>
<pre>reinesupersauersupesupersupe
supersupe
</pre>
<pre>reinesupersauersupesupersupe
supersupe
</pre>
<pre>reinesupersauersupe<u>supersupe</u>
<u>supersupe</u>
</pre>
<p>Muster wurde gefunden.
Zusammen mit der „Bad-Character-Heuristik“ könnten die letzten 3 Iterationen übersprungen werden, da wir bis zum nächsten „r“ im Muster verschieben können.
</p>
<div class="mw-heading mw-heading2"><h2 id="Laufzeit">Laufzeit</h2></div>
<p>Im Folgenden wird die <a href="Landau-Notation" class="mw-redirect" title="Landau-Notation">Landau-Notation</a> verwendet, um das asymptotische Verhalten der Laufzeit anzugeben.
Sucht der Boyer-Moore-Algorithmus nur das erste Auftreten des Musters, hat er eine Worst-Case-Komplexität von <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \Theta \left(n+m\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi mathvariant="normal">Θ<!-- Θ --></mi>
<mrow>
<mo>(</mo>
<mrow>
<mi>n</mi>
<mo>+</mo>
<mi>m</mi>
</mrow>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \Theta \left(n+m\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/548fc0ba1a2305096e270a17a66c47b106298682.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:10.28ex; height:2.843ex;" alt="{\displaystyle \Theta \left(n+m\right)}" loading="lazy"></span>.
Wird er jedoch benutzt, um alle Matches des Musters zu finden, ist die
Worst-Case-Komplexität <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \Theta \left(n\cdot m\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi mathvariant="normal">Θ<!-- Θ --></mi>
<mrow>
<mo>(</mo>
<mrow>
<mi>n</mi>
<mo>⋅<!-- ⋅ --></mo>
<mi>m</mi>
</mrow>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \Theta \left(n\cdot m\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/fdc704d9de72c93d5e78ae9b401b1e3a93152147.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:9.119ex; height:2.843ex;" alt="{\displaystyle \Theta \left(n\cdot m\right)}" loading="lazy"></span>. Diese Komplexität kann jedoch durch eine zusätzliche Regel für den Fall, dass im letzten Schritt das Muster gefunden wurde, wieder auf <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \Theta \left(n+m\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi mathvariant="normal">Θ<!-- Θ --></mi>
<mrow>
<mo>(</mo>
<mrow>
<mi>n</mi>
<mo>+</mo>
<mi>m</mi>
</mrow>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \Theta \left(n+m\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/548fc0ba1a2305096e270a17a66c47b106298682.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:10.28ex; height:2.843ex;" alt="{\displaystyle \Theta \left(n+m\right)}" loading="lazy"></span> reduziert werden.
Verwendet man den Algorithmus jedoch für ein relativ kleines Muster und ein großes Alphabet, erhält man eine Average-Case-Komplexität von <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \Theta \left({\frac {n}{m}}\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi mathvariant="normal">Θ<!-- Θ --></mi>
<mrow>
<mo>(</mo>
<mrow class="MJX-TeXAtom-ORD">
<mfrac>
<mi>n</mi>
<mi>m</mi>
</mfrac>
</mrow>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \Theta \left({\frac {n}{m}}\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/ac9ec0a9bc51b546a6076400dbe6689548180926.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.838ex; width:7.847ex; height:4.843ex;" alt="{\displaystyle \Theta \left({\frac {n}{m}}\right)}" loading="lazy"></span>.
</p>
<div class="mw-heading mw-heading3"><h3 id="Bad-Character-Heuristik_2">Bad-Character-Heuristik</h3></div>
<p>Verwendet man nur die Bad-Character-Heuristik, erhält man immer noch eine Average-Case-Komplexität von <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \Theta \left({\frac {n}{m}}\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi mathvariant="normal">Θ<!-- Θ --></mi>
<mrow>
<mo>(</mo>
<mrow class="MJX-TeXAtom-ORD">
<mfrac>
<mi>n</mi>
<mi>m</mi>
</mfrac>
</mrow>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \Theta \left({\frac {n}{m}}\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/ac9ec0a9bc51b546a6076400dbe6689548180926.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.838ex; width:7.847ex; height:4.843ex;" alt="{\displaystyle \Theta \left({\frac {n}{m}}\right)}" loading="lazy"></span>, muss aber eine Worst-Case-Komplexität von <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \Theta \left(n\cdot m\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi mathvariant="normal">Θ<!-- Θ --></mi>
<mrow>
<mo>(</mo>
<mrow>
<mi>n</mi>
<mo>⋅<!-- ⋅ --></mo>
<mi>m</mi>
</mrow>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \Theta \left(n\cdot m\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/fdc704d9de72c93d5e78ae9b401b1e3a93152147.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:9.119ex; height:2.843ex;" alt="{\displaystyle \Theta \left(n\cdot m\right)}" loading="lazy"></span> in Kauf nehmen. Ein Worst-Case-Beispiel ist der Text <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle T=a^{n}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>T</mi>
<mo>=</mo>
<msup>
<mi>a</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>n</mi>
</mrow>
</msup>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle T=a^{n}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/a8a7d8389009e6b196a7710cd46f9cdfe3f31811.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:7.183ex; height:2.343ex;" alt="{\displaystyle T=a^{n}}" loading="lazy"></span> gemeinsam mit dem Muster <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle M=ba^{m-1}}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>M</mi>
<mo>=</mo>
<mi>b</mi>
<msup>
<mi>a</mi>
<mrow class="MJX-TeXAtom-ORD">
<mi>m</mi>
<mo>−<!-- − --></mo>
<mn>1</mn>
</mrow>
</msup>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle M=ba^{m-1}}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/1522ff66fedd02560f2f5bd005faf65d347989f9.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:11.544ex; height:2.676ex;" alt="{\displaystyle M=ba^{m-1}}" loading="lazy"></span>.
Hier wird immer das ganze Muster mit dem Text verglichen, bis an der ersten Stelle ein Mismatch auftritt. Nach einem solchen Mismatch kann das Muster (mittels Bad-Character-Heuristik) aber nur um eine Stelle nach rechts verschoben werden.
</p>
<div class="mw-heading mw-heading2"><h2 id="Beispielcode_in_C++"><span id="Beispielcode_in_C.2B.2B"></span>Beispielcode in C++</h2></div>
<p>In der Praxis wendet der Algorithmus beide Regeln an und nutzt immer die Regel, die das Muster am weitesten springen lässt, für die „Guter-Suffix-Regel“ sowie für die „Schlechtes-Zeichen-Regel“ erstellt man zu Beginn der Suche jeweils eine Sprungtabelle (siehe „charTable“ und „offsetTable“ im Code).
</p><p>Im folgenden Quellcode geschieht das Anlegen der „Guter-Suffix-Regel“-Tabelle (charTable) im (unwahrscheinlichen) schlechtesten Fall in <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle O\left(m^{2}\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>O</mi>
<mrow>
<mo>(</mo>
<msup>
<mi>m</mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>2</mn>
</mrow>
</msup>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle O\left(m^{2}\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/3ca3a262d1f2da57c639b2ca1d5ba1f76df48e78.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.005ex; width:7.385ex; height:3.343ex;" alt="{\displaystyle O\left(m^{2}\right)}" loading="lazy"></span>, was bei nicht zu großen Mustern zu vernachlässigen ist. Die Suche nach dem Suffix für die „Schlechtes-Zeichen-Regel“-Tabelle lässt sich beispielsweise über den <a href="Knuth-Morris-Pratt-Algorithmus" title="Knuth-Morris-Pratt-Algorithmus">KMP</a>-Algorithmus machen, was hier aber der Übersichtlichkeit wegen vermieden wird. Damit liegt folgender Algorithmus in <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle O\left(n+m^{2}\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mi>O</mi>
<mrow>
<mo>(</mo>
<mrow>
<mi>n</mi>
<mo>+</mo>
<msup>
<mi>m</mi>
<mrow class="MJX-TeXAtom-ORD">
<mn>2</mn>
</mrow>
</msup>
</mrow>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle O\left(n+m^{2}\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/7a61c5d81675c005c9f7c4eb715093c3840ba7a3.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.005ex; width:11.62ex; height:3.343ex;" alt="{\displaystyle O\left(n+m^{2}\right)}" loading="lazy"></span>.
</p><p>Lässt man sich die Anzahl der benötigten Vergleiche ausgeben, so sind dies bei einem großen Alphabet erstaunlich wenige und der Boyer-Moore-Algorithmus ist beispielsweise dem <a href="Knuth-Morris-Pratt-Algorithmus" title="Knuth-Morris-Pratt-Algorithmus">Knuth-Morris-Pratt-Algorithmus</a> vorzuziehen.
</p>
<div class="mw-highlight mw-highlight-lang-c++ mw-content-ltr" dir="ltr"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;algorithm&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;iostream&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;limits&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;string_view&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;vector&gt;</span>

<span class="k">using</span><span class="w"> </span><span class="k">namespace</span><span class="w"> </span><span class="nn">std</span><span class="p">;</span>

<span class="cm">/**</span>
<span class="cm"> * Ist needle[position] bis needle[needle.size() - 1] ein Präfix von needle?</span>
<span class="cm"> */</span>
<span class="kt">bool</span><span class="w"> </span><span class="nf">isPrefix</span><span class="p">(</span><span class="n">string_view</span><span class="w"> </span><span class="n">needle</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">position</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">position</span><span class="p">,</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">();</span><span class="w"> </span><span class="o">++</span><span class="n">i</span><span class="p">,</span><span class="w"> </span><span class="o">++</span><span class="n">j</span><span class="p">)</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">needle</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">needle</span><span class="p">[</span><span class="n">j</span><span class="p">])</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">false</span><span class="p">;</span>

<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="nb">true</span><span class="p">;</span>
<span class="p">}</span>

<span class="cm">/**</span>
<span class="cm"> * Gibt die maximale Länge der Teilzeichenfolge zurück, die bei position endet</span>
<span class="cm"> * und ein Suffix ist. (Hilfsfunktion für Guter-Suffix-Regel)</span>
<span class="cm"> */</span>
<span class="kt">int</span><span class="w"> </span><span class="nf">suffixSize</span><span class="p">(</span><span class="n">string_view</span><span class="w"> </span><span class="n">needle</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">position</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">position</span><span class="p">,</span><span class="w"> </span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>

<span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="p">(</span><span class="n">i</span><span class="w"> </span><span class="o">&gt;=</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="k">and</span><span class="w"> </span><span class="n">needle</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">needle</span><span class="p">[</span><span class="n">j</span><span class="p">])</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="o">--</span><span class="n">i</span><span class="p">;</span>
<span class="w"> </span><span class="o">--</span><span class="n">j</span><span class="p">;</span>
<span class="w"> </span><span class="o">++</span><span class="n">size</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>

<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">size</span><span class="p">;</span>
<span class="p">}</span>

<span class="cm">/**</span>
<span class="cm"> * Erstellt die Sprungtabelle basierend auf den nicht übereinstimmenden</span>
<span class="cm"> * Zeicheninformationen. (Schlechtes-Zeichen-Regel)</span>
<span class="cm"> */</span>
<span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span><span class="w"> </span><span class="n">makeCharTable</span><span class="p">(</span><span class="n">string_view</span><span class="w"> </span><span class="n">needle</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">table</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span><span class="p">(</span><span class="n">numeric_limits</span><span class="o">&lt;</span><span class="kt">char</span><span class="o">&gt;::</span><span class="n">max</span><span class="p">());</span>

<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="o">&amp;</span><span class="n">value</span><span class="o">:</span><span class="w"> </span><span class="n">table</span><span class="p">)</span>
<span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">();</span>

<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="o">++</span><span class="n">i</span><span class="p">)</span>
<span class="w"> </span><span class="n">table</span><span class="p">[</span><span class="n">needle</span><span class="p">[</span><span class="n">i</span><span class="p">]]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">i</span><span class="p">;</span>

<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">table</span><span class="p">;</span>
<span class="p">}</span>

<span class="cm">/**</span>
<span class="cm"> * Erstellt die Sprungtabelle basierend auf dem Scanoffset, bei dem eine</span>
<span class="cm"> * Nichtübereinstimmung auftritt. (Guter-Suffix-Regel)</span>
<span class="cm"> */</span>
<span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span><span class="w"> </span><span class="n">makeOffsetTable</span><span class="p">(</span><span class="n">string_view</span><span class="w"> </span><span class="n">needle</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">table</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span><span class="p">(</span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">());</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">lastPrefixPosition</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">();</span>

<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">();</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="o">--</span><span class="n">i</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">isPrefix</span><span class="p">(</span><span class="n">needle</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">))</span>
<span class="w"> </span><span class="n">lastPrefixPosition</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">i</span><span class="p">;</span>

<span class="w"> </span><span class="n">table</span><span class="p">[</span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">lastPrefixPosition</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">();</span>
<span class="w"> </span><span class="p">}</span>

<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="o">++</span><span class="n">i</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">suffixSize</span><span class="p">(</span><span class="n">needle</span><span class="p">,</span><span class="w"> </span><span class="n">i</span><span class="p">);</span>
<span class="w"> </span><span class="n">table</span><span class="p">[</span><span class="n">size</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">size</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>

<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">table</span><span class="p">;</span>
<span class="p">}</span>

<span class="cm">/**</span>
<span class="cm"> * Gibt den Index innerhalb der Zeichenfolge des ersten Auftretens vom</span>
<span class="cm"> * spezifizierten Teilstring zurück. Wenn es sich nicht um einen Teilstring</span>
<span class="cm"> * handelt, wird -1 zurückgegeben.</span>
<span class="cm"> */</span>
<span class="kt">int</span><span class="w"> </span><span class="n">indexOf</span><span class="p">(</span><span class="n">string_view</span><span class="w"> </span><span class="n">haystack</span><span class="p">,</span><span class="w"> </span><span class="n">string_view</span><span class="w"> </span><span class="n">needle</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>

<span class="w"> </span><span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span><span class="w"> </span><span class="n">charTable</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">makeCharTable</span><span class="p">(</span><span class="n">needle</span><span class="p">);</span>
<span class="w"> </span><span class="n">vector</span><span class="o">&lt;</span><span class="kt">int</span><span class="o">&gt;</span><span class="w"> </span><span class="n">offsetTable</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">makeOffsetTable</span><span class="p">(</span><span class="n">needle</span><span class="p">);</span>

<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">j</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">haystack</span><span class="p">.</span><span class="n">size</span><span class="p">();)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">j</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="n">needle</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">haystack</span><span class="p">[</span><span class="n">i</span><span class="p">];</span><span class="w"> </span><span class="o">--</span><span class="n">i</span><span class="p">,</span><span class="w"> </span><span class="o">--</span><span class="n">j</span><span class="p">)</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">j</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">i</span><span class="p">;</span>

<span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">max</span><span class="p">(</span><span class="n">offsetTable</span><span class="p">[</span><span class="n">needle</span><span class="p">.</span><span class="n">size</span><span class="p">()</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">j</span><span class="p">],</span><span class="w"> </span><span class="n">charTable</span><span class="p">[</span><span class="n">haystack</span><span class="p">[</span><span class="n">i</span><span class="p">]]);</span>
<span class="w"> </span><span class="p">}</span>

<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">-1</span><span class="p">;</span>
<span class="p">}</span>

<span class="kt">int</span><span class="w"> </span><span class="n">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">string_view</span><span class="w"> </span><span class="n">haystack</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">"ttabarbsxfarbbarb"</span><span class="p">;</span>
<span class="w"> </span><span class="n">string_view</span><span class="w"> </span><span class="n">needle</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">"arbbarb"</span><span class="p">;</span>
<span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">"found at position "</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">indexOf</span><span class="p">(</span><span class="n">haystack</span><span class="p">,</span><span class="w"> </span><span class="n">needle</span><span class="p">)</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">endl</span><span class="p">;</span>

<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Literatur">Literatur</h2></div>
<ul><li><a href="Robert_S._Boyer" title="Robert S. Boyer">Robert S. Boyer</a>, <a href="J._Strother_Moore" class="mw-redirect" title="J. Strother Moore">J. Strother Moore</a>: <i>A fast string searching algorithm</i>. In: <i>Communications of the ACM.</i> Bd. 20, Nr. 10, <span class="-print"><a href="Internationale_Standardnummer_f%C3%BCr_fortlaufende_Sammelwerke" title="Internationale Standardnummer für fortlaufende Sammelwerke">ISSN</a>&nbsp;<span style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://zdb-katalog.de/list.xhtml?t=iss%3D%220001-0782%22&amp;key=cql">0001-0782</a></span></span>, S. 762–772, <a rel="nofollow" class="external text" href="https://www.cs.utexas.edu/~moore/publications/fstrpos.pdf">Onlineversion (PDF; 1,19 MB)</a>, <a href="Digital_Object_Identifier" title="Digital Object Identifier">doi</a>:<span class="uri-handle" style="white-space:nowrap"><a rel="nofollow" class="external text" href="https://doi.org/10.1145/359842.359859">10.1145/359842.359859</a></span>.</li></ul>
<ul><li>Robert S. Boyer, J. Strother Moore: <i>A Lemma Driven Automatic Theorem Prover for Recursive Function Theory.</i> In: <i>5th International Joint Conference on Artificial Intelligence, 1977, IJCAI-77. Proceedings of the Conference. Massachusetts Institute of Technology, Cambridge, Massachusetts, USA, August 22–25, 1977.</i> Band 2. Morgan Kaufmann Publishers Inc., Los Altos CA 1977, ISBN 0-934613-48-6, S. 511–519, <a rel="nofollow" class="external text" href="https://www.ijcai.org/Proceedings/77-1/Papers/089.pdf">Onlineversion (PDF; 240 kB)</a>.</li></ul>
<ul><li>Markus E. Nebel: <i>Texte durchsuchen – aber schnell! Der Boyer-Moore-Horspool Algorithmus</i>. In: Taschenbuch der Algorithmen. Hrsg. von Berthold Vöcking, Helmut Alt, <a href="Martin_Dietzfelbinger" title="Martin Dietzfelbinger">Martin Dietzfelbinger</a>, Rüdiger Reischuk, Christian Scheideler, <a href="Heribert_Vollmer" title="Heribert Vollmer">Heribert Vollmer</a> und <a href="Dorothea_Wagner" title="Dorothea Wagner">Dorothea Wagner</a>. Berlin, Heidelberg: Springer Verlag 2008, S. 51–60. ISBN 978-3-540-76394-9</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Weblinks">Weblinks</h2></div>
<ul><li><a rel="nofollow" class="external text" href="https://www.inf.hs-flensburg.de/lang/algorithmen/pattern/bm.htm">Eine ausführlichere Erklärung bei der Hochschule Flensburg</a></li>
<li>University of British Columbia: <a rel="nofollow" class="external text" href="https://cmps-people.ok.ubc.ca/ylucet/DS/BoyerMoore.html">Boyer-Moore String Search</a>, Webseite zur Visualisierung des Boyer-Moore-Algorithmus</li>
<li><a rel="nofollow" class="external text" href="https://www.cs.utexas.edu/users/moore/best-ideas/string-searching/">Ein ausführliches Beispiel von Miterfinder</a> <a href="J_Strother_Moore" title="J Strother Moore">J Strother Moore</a></li>
<li><a rel="nofollow" class="external text" href="https://users.dcc.uchile.cl/~rbaeza/handbook/algs/7/713b.srch.c.html">Boyer-Moore-Horspool-Algorithmus</a></li></ul></div><!--htdig_noindex--><div><div class="zim-footer">
Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2023-02-28" href="https://de.wikipedia.org/wiki/?title=Boyer-Moore-Algorithmus&amp;oldid=231332000">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>

</body></html>